home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 526-550 / disk_535 / keymacro / mrarpfile.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  17KB  |  677 lines
  1. /*  File support routines to complement ARP.
  2.  *  Author: Mark R. Rinfret
  3.  *          Usenet:     mrr@amanpt1.Newport.RI.US
  4.  *          BIX:        markr
  5.  *          CIS:        72017, 136 (good luck!)
  6.  *
  7.  *          348 Indian Avenue
  8.  *          Portsmouth, RI 02871
  9.  *          401-846-7639 (home)
  10.  *          401-849-9390 (work)       
  11.  *
  12.  *  This package was written primarily because of _one_ missing element
  13.  *  in ARP: FGets. ARGH! ARPFFFT! It extends ARP by adding buffering to
  14.  *  the basic file type (FileHandle) and defining a new type, named
  15.  *  ARPFileHandle (hope this is OK with the ARP guys). Also, I've used the
  16.  *  convention of embedding ARP (vs. Arp in MicroSmith's stuff) in all type
  17.  *  and function names to (hopefully) avoid naming collisions.
  18.  *
  19.  *  This package (as far as I am concerned) is public domain. Use it any
  20.  *  way you like. Some comments on the "MR" prefix: it isn't short for
  21.  *  "Mister", it comprises the initials of my first and last names;
  22.  *  I use it primarily to avoid name collisions with stuff by other
  23.  *  authors. If any other authors whose initials are "MR" start doing
  24.  *  this, we'll probably have to appeal to Electronic Arts to dole out
  25.  *  "author codes" along the lines of those issued for IFF :-). I hereby
  26.  *  stake a claim to 'MRR_'.
  27.  *
  28.  *  A word of warning:
  29.  *
  30.  *  DO NOT INTERMIX STANDARD AMIGADOS FILE SUPPORT CALLS WITH CALLS TO
  31.  *  THIS PACKAGE ON FILES USING THIS FILE METHOD!
  32.  *
  33.  *  Obviously, the system doesn't know about the buffering added here
  34.  *  and will cause unpredictable results (unless, of course, you
  35.  *  take care to maintain the ARPFileHandle information).
  36.  */
  37.  
  38. /*  Olsen: In order to adapt the code to ANSI some declarations and
  39.  *         function calls were rearranged. I also fixed two parts of
  40.  *         code which appeared not to work correctly.
  41.  */
  42.  
  43.     /* Skip prototypes. */
  44.  
  45. #define _MRARPFILE_PRIVATE 1
  46.  
  47. #include "MRARPFile.h"
  48.  
  49. /* StoreTracker is my attempt to fix an apparent bug in ARP 1.3. I have
  50.  * found that the LastTracker kludge (via IoErr()) doesn't work reliably.
  51.  * StoreTracker simply stuffs A1 into D0 and returns . It *MUST* be
  52.  * called immediately after any ARP call which allocates a tracker to
  53.  * assure that the value is correct.
  54.  */
  55.  
  56. struct DefaultTracker *    StoreTracker(VOID);
  57.  
  58. char *            FGetsARP(char *s,LONG length,ARPFileHandle *file);
  59. static LONG        FillARPFileBuffer(ARPFileHandle *file);
  60. static LONG        FlushARPFileBuffer(ARPFileHandle *file);
  61. LONG            FPutsARP(char *s,ARPFileHandle *file);
  62. LONG            ReadARPFile(ARPFileHandle *file,UBYTE *buffer,LONG length);
  63. LONG            CloseARPFile(ARPFileHandle *file);
  64. ARPFileHandle *        OpenARPFile(char *name,LONG accessMode,LONG bytes);
  65. LONG            SeekARPFile(ARPFileHandle *file,LONG position,LONG mode);
  66. LONG            WriteARPFile(ARPFileHandle *file,UBYTE *buffer,LONG length);
  67.  
  68. /*  FUNCTION
  69.  *      FGetsARP - get string from a buffered ARP file.
  70.  *
  71.  *  SYNOPSIS
  72.  *      char *FGetsARP(s, length, file)
  73.  *                     UBYTE         *s;
  74.  *                     LONG           length;
  75.  *                     ARPFileHandle *file;
  76.  *
  77.  *  DESCRIPTION
  78.  *      FGetsARP models the behavior of the "standard" fgets, except that
  79.  *      it is used with a buffered ARP file. The data is read from <file>
  80.  *      and transfered to string <s>. Up to length-1 characters will be
  81.  *      read. Reading is also terminated upon receipt of a newline
  82.  *      or detection of end-of-file. 
  83.  *
  84.  *      If the <file> was opened without a buffer, one of MaxInputBuf
  85.  *      bytes will be allocated.
  86.  *
  87.  *      If end of file or an error is detected, the return value will be
  88.  *      NULL. Otherwise, the return value will be <s>. <s> will be 
  89.  *      terminated with a null byte.
  90.  */
  91.  
  92. char *
  93. FGetsARP(char *s,LONG length,ARPFileHandle *file)
  94. {
  95.     struct DefaultTracker    *tracker;
  96.     LONG             bytesNeeded = length - 1;
  97.     LONG             bytesRead = 0;
  98.     char             c;
  99.     char            *s1 = s;
  100.  
  101.     /* Set string initially empty to protect user from failure to check
  102.      * return value.
  103.      */
  104.  
  105.     *s1 = '\0';    
  106.  
  107.     if(file -> mode != MODE_OLDFILE)
  108.         file -> lastError = ERROR_READ_PROTECTED;
  109.          
  110.     if(file -> lastError)
  111.     {
  112. dangit:        return(NULL);
  113.     }
  114.  
  115.         /* Ohmigosh! No buffer? */
  116.  
  117.     if(!file -> buf)
  118.     {
  119.         file -> buf = ArpAllocMem(MaxInputBuf, MEMF_CLEAR | MEMF_PUBLIC);
  120.  
  121.         tracker = StoreTracker();
  122.  
  123.         if(!file -> buf)
  124.         {
  125.             file -> lastError = ERROR_NO_FREE_STORE;
  126.             goto dangit;
  127.         }
  128.  
  129.         file -> bufSize        = MaxInputBuf;    /* bufLength, bufPos are zero. */
  130.         file -> bufTracker    = tracker;
  131.     }
  132.  
  133.     while(bytesNeeded)
  134.     {
  135.         if(file -> bufPos >= file -> bufLength)
  136.         {
  137.             if(FillARPFileBuffer(file) < 0)
  138.                 goto dangit;
  139.  
  140.             if(!file -> bufLength)
  141.                 break;
  142.         }
  143.  
  144.         c = file -> buf[file -> bufPos++];
  145.  
  146.         ++bytesRead;
  147.  
  148.         if(c == '\n')
  149.             break;
  150.  
  151.         *s1++ = c;
  152.  
  153.         --bytesNeeded; 
  154.     }
  155.  
  156.     *s1 = '\0';
  157.  
  158.     return(bytesRead ? s : NULL);
  159. }
  160.  
  161. /*  FUNCTION
  162.  *      FillARPFileBuffer - read data into ARPFile buffer.
  163.  *
  164.  *  SYNOPSIS
  165.  *      static LONG FillARPFileBuffer(file)
  166.  *                                    ARPFileHandle *file;
  167.  *
  168.  *  DESCRIPTION
  169.  *      Attempt to fill the buffer associated with <file> by reading
  170.  *      data from the associated external file. The return value will
  171.  *      be one of the following:
  172.  *          >0  => number of bytes read
  173.  *           0  => end of file
  174.  *          -1  => a Bad Thing happened (error code in file -> lastError) 
  175.  *
  176.  *      Note: this is a local routine and is thus declared as "static".
  177.  *      Please inform the author if this is a hardship.
  178.  */
  179.  
  180. static LONG
  181. FillARPFileBuffer(ARPFileHandle *file)
  182. {
  183.     /* Remember where we were. The user might want to try error
  184.      * recovery. Of course, this probably isn't enough info, but
  185.      * it's a start.
  186.      */
  187.  
  188.     file -> lastPosition    = Seek(file -> fh, 0L, OFFSET_CURRENT);
  189.     file -> bufPos        = 0;
  190.     file -> bufLength    = Read(file -> fh, file -> buf, file -> bufSize);
  191.  
  192.         /* We got trubble! */
  193.  
  194.     if(file -> bufLength == -1)
  195.         file -> lastError = IoErr();
  196.     else
  197.     {
  198.         if(!file -> bufLength)
  199.             file -> endOfFile = TRUE;
  200.     }
  201.  
  202.     return(file -> bufLength);
  203. } 
  204.  
  205. /*  FUNCTION
  206.  *      FlushARPFileBuffer - write file buffer contents to disk.
  207.  *
  208.  *  SYNOPSIS
  209.  *      static LONG FlushARPFileBuffer(file)
  210.  *                                     ARPFileHandle *file;
  211.  *  DESCRIPTION
  212.  *      FlushARPFileBuffer writes the contents of <file>'s buffer
  213.  *      (if any) to disk and resets the buffer information. The
  214.  *      return value may be any of:
  215.  *
  216.  *          >0 =>   number of bytes written
  217.  *           0 =>   nothing in buffer
  218.  *          <0 =>   negated error code
  219.  *
  220.  *      Note: it is assumed that this function will only be used locally
  221.  *      and therefore need not be public. If you disagree, please contact
  222.  *      the author.
  223.  */
  224.  
  225. static LONG
  226. FlushARPFileBuffer(ARPFileHandle *file)
  227. {
  228.     LONG bytesWritten = 0;
  229.  
  230.     /* This operation is only allowed for output files. */
  231.  
  232.     if(file -> mode != MODE_NEWFILE)
  233.     {
  234.         file -> lastError = ERROR_WRITE_PROTECTED;
  235.  
  236. badstuff:    return(-file -> lastError);
  237.     }
  238.  
  239.     if(file -> lastError)
  240.         goto badstuff; /* Residual error? */
  241.  
  242.     if(file -> bufLength)
  243.     {
  244.         file -> lastPosition = Seek(file -> fh, 0L, OFFSET_CURRENT);
  245.  
  246.         bytesWritten = Write(file -> fh, file -> buf, file -> bufLength);
  247.  
  248.         if(bytesWritten != file -> bufLength)
  249.         {
  250.             file -> lastError = IoErr();
  251.             goto badstuff;
  252.         }
  253.         else
  254.         {
  255.             file -> bufLength    = 0;
  256.             file -> bufPos        = 0;
  257.         }
  258.     }
  259.  
  260.     return(bytesWritten);
  261. }
  262.  
  263. /*  FUNCTION
  264.  *      FPutsARP - write a string to a buffered ARP file.
  265.  *
  266.  *  SYNOPSIS
  267.  *      LONG FPutsARP(s, file)
  268.  *                    char          *s;
  269.  *                    ARPFileHandle *file;
  270.  *
  271.  *  DESCRIPTION
  272.  *      FPutsARP writes the contents of string <s> to the specified <file>.
  273.  *      If successful, it returns 0. On failure, it returns the negated
  274.  *      system error code. 
  275.  */
  276.  
  277. LONG
  278. FPutsARP(char *s,ARPFileHandle *file)
  279. {
  280.     LONG     bytesLeft, bytesUsed;
  281.     char    *s1 = s;
  282.  
  283.     if(file -> mode != MODE_NEWFILE) 
  284.         file -> lastError = ERROR_WRITE_PROTECTED;
  285.  
  286.     if(file -> lastError)
  287.     {
  288. shucks:        return(-file -> lastError);
  289.     }
  290.  
  291.     bytesLeft = strlen(s);
  292.  
  293.     /* Attempt to be smart about this transfer. Copy the string to the
  294.      * buffer in chunks. There is a possibility that the string is bigger
  295.      * than the size of the buffer.
  296.      */
  297.  
  298.     while(bytesLeft)
  299.     {
  300.         if(file -> bufPos >= file -> bufSize)
  301.         {
  302.             if(FlushARPFileBuffer(file) <= 0)
  303.                 goto shucks;
  304.         }
  305.  
  306.         bytesUsed = MIN(file -> bufSize - file -> bufPos, bytesLeft);
  307.  
  308.         CopyMem(s1, &file -> buf[file -> bufPos], bytesUsed);
  309.  
  310.         s1 += bytesUsed;
  311.  
  312.         file -> bufLength = (file -> bufPos += bytesUsed);
  313.  
  314.         bytesLeft -= bytesUsed;
  315.     }
  316.  
  317.     return(0);
  318. }
  319.  
  320. /*  FUNCTION
  321.  *      ReadARPFile - read from a buffered ARP file.
  322.  *
  323.  *  SYNOPSIS
  324.  *      LONG ReadARPFile(file, buffer, length)
  325.  *                       ARPFile *file;
  326.  *                       UBYTE   *buffer;
  327.  *                       LONG    length;
  328.  *
  329.  *  DESCRIPTION
  330.  *      ReadARPFile attempts to read <length> bytes from <file>, transferring
  331.  *      the data to <buffer>. 
  332.  *
  333.  *      The return value may be any of the following:
  334.  *
  335.  *          >0      number of bytes transferred
  336.  *          0       end of file
  337.  *         <0       negated error code
  338.  *
  339.  *      Note: if the lastError field of the <file> descriptor contains a
  340.  *            non-zero value, its negated value will be returned and no
  341.  *            attempt will be made to read the file. If you attempt error
  342.  *            recovery, you must clear this field to zero.
  343.  */
  344.  
  345. LONG
  346. ReadARPFile(ARPFileHandle *file,UBYTE *buffer,LONG length)
  347. {
  348.     LONG    bytesLeft;
  349.     LONG    bytesRead = 0;
  350.     LONG    needBytes = length;
  351.     LONG    pos = 0;
  352.     LONG    usedBytes = 0;
  353.  
  354.         /* Prevent read if this file opened for writing. */
  355.  
  356.     if(file -> mode != MODE_OLDFILE)
  357.         file -> lastError = ERROR_READ_PROTECTED;
  358.  
  359.         /* Have residual error? */
  360.  
  361.     if(file -> lastError)
  362.     {
  363. boofar:        return(-file -> lastError);
  364.     }
  365.  
  366.         /* No buffer? */
  367.  
  368.     if(!file -> buf )
  369.     {
  370.         bytesRead = Read(file -> fh, buffer, length);
  371.  
  372.         if(bytesRead == -1)
  373.         {
  374.             file -> lastError = IoErr();
  375.             goto boofar;
  376.         }
  377.     }
  378.     else
  379.     {
  380.         while(needBytes)
  381.         {
  382.             if(file -> bufLength - file -> bufPos <= 0)
  383.             {
  384.                 if(FillARPFileBuffer(file) == -1)
  385.                     goto boofar;
  386.  
  387.                 if(!file -> bufLength)
  388.                     break;
  389.             }
  390.  
  391.             bytesLeft = file -> bufLength - file -> bufPos;
  392.  
  393.             usedBytes = MIN(bytesLeft, length);
  394.  
  395.             CopyMem(&file -> buf[file -> bufPos], &buffer[pos], usedBytes);
  396.  
  397.             file -> bufPos += usedBytes;
  398.  
  399.             pos += usedBytes;
  400.  
  401.             bytesRead += usedBytes;
  402.             needBytes -= usedBytes;
  403.         }
  404.     }
  405.  
  406.     return(bytesRead);
  407. }
  408.  
  409. /*  FUNCTION
  410.  *      CloseARPFile - close buffered ARP file.
  411.  *
  412.  *  SYNOPSIS
  413.  *      LONG CloseARPFile(file)
  414.  *                        ARPFileHandle *file;
  415.  *
  416.  *  DESCRIPTION
  417.  *      CloseARPFile closes the file described by <file> which MUST have
  418.  *      been opened by OpenARPFile. It releases all tracked items
  419.  *      associated with <file>, as well.
  420.  *
  421.  *      The return value is only meaningful for output files. If, upon
  422.  *      flushing the buffer, a write error is detected, a system error
  423.  *      code (ERROR_DISK_FULL, etc.) will be returned.
  424.  */
  425.  
  426. LONG
  427. CloseARPFile(ARPFileHandle *file)
  428. {
  429.     LONG result = 0;
  430.  
  431.         /* Just in case... */
  432.  
  433.     if(file)
  434.     {
  435.         if(file -> fileTracker)
  436.         {
  437.             /* Any left-over stuff in the buffer? If so, we must flush
  438.              * it to disk. However, if an error was detected in the
  439.              * previous operation, punt. 
  440.              */
  441.  
  442.             if((file -> mode == MODE_NEWFILE) && ! file -> lastError && file -> bufLength)
  443.             {
  444.                 if(Write(file -> fh, file -> buf, file -> bufLength) != file -> bufLength)
  445.                     result = IoErr();
  446.             }
  447.  
  448.             FreeTrackedItem(file -> fileTracker);
  449.         }
  450.  
  451.         if(file -> bufTracker)
  452.             FreeTrackedItem(file -> bufTracker);
  453.  
  454.         FreeTrackedItem(file -> myTracker);
  455.     }
  456.  
  457.     return(result);
  458. }
  459.  
  460. /*  FUNCTION
  461.  *      OpenARPFile - open a buffered ARP file
  462.  *
  463.  *  SYNOPSIS
  464.  *      struct MRARPFile *OpenARPFile(name, accessMode, bytes)
  465.  *                                    char *name;
  466.  *                                    LONG accessMode, bytes;
  467.  *
  468.  *  DESCRIPTION
  469.  *      OpenARPFile opens the file <name>, with the given <accessMode>
  470.  *      (MODE_OLDFILE, MODE_NEWFILE only!) for buffered access. The
  471.  *      size of the local buffer is specified by <bytes>.
  472.  *
  473.  *      A zero value for <bytes> is OK and is sometimes appropriate, as
  474.  *      when performing file copy operations, etc. However, if a file
  475.  *      opened with a zero length buffer is then passed to the
  476.  *      FGetsARP function, "spontaneous buffer allocation" will occur.
  477.  *      No biggy, really, just something you should know. The ARP constant,
  478.  *      MaxInputBuf will be used for the buffer size, in this case.
  479.  *
  480.  *      If successful, a pointer to the file tracking structure is 
  481.  *      returned. Otherwise, the return value will be NULL.
  482.  *
  483.  *      OpenARPFile uses full resource tracking for all information
  484.  *      associated with the file.
  485.  *
  486.  */
  487.  
  488. ARPFileHandle *
  489. OpenARPFile(char *name,LONG accessMode,LONG bytes)
  490. {
  491.     struct DefaultTracker    *lastTracker;
  492.     ARPFileHandle        *theFile = NULL;
  493.     BPTR             fh;
  494.  
  495.         /* This package does not support READ/WRITE access! */
  496.  
  497.     if((accessMode != MODE_OLDFILE) && (accessMode != MODE_NEWFILE))
  498.         return(NULL);
  499.  
  500.     /* 
  501.      * Note: I'm using ArpAllocMem vs. ArpAlloc here because it appears
  502.      * that ArpAlloc gives me a bad tracker pointer (?).
  503.      */
  504.  
  505.     theFile = ArpAllocMem((LONG) sizeof(ARPFileHandle), MEMF_PUBLIC | MEMF_CLEAR);
  506.  
  507.     lastTracker = StoreTracker();
  508.  
  509.     if(theFile)
  510.     {
  511.         theFile -> myTracker = lastTracker;
  512.         theFile -> mode = accessMode;
  513.  
  514.         fh = ArpOpen(name, accessMode);
  515.  
  516.         lastTracker = StoreTracker();
  517.  
  518.         if(!fh)
  519.         {
  520. fungu:            CloseARPFile(theFile);    /* Don't worry - it's "smart". */
  521.             theFile = NULL;
  522.  
  523.             return(NULL);        /* This one was missing -Olsen */
  524.         }
  525.  
  526.         theFile -> fileTracker    = lastTracker;
  527.         theFile -> fh        = fh;
  528.  
  529.             /* Does user want a buffer? */
  530.  
  531.         if(bytes)
  532.         {
  533.             theFile -> buf = ArpAllocMem(bytes, MEMF_PUBLIC | MEMF_CLEAR);
  534.  
  535.             lastTracker = StoreTracker();
  536.  
  537.             if(!theFile -> buf)
  538.                 goto fungu;
  539.  
  540.             theFile -> bufSize    = bytes;
  541.             theFile -> bufTracker    = lastTracker;
  542.         }
  543.     }
  544.  
  545.     return(theFile);
  546. }
  547.  
  548. /*  FUNCTION
  549.  *      SeekARPFile - move to new logical position in file.
  550.  *
  551.  *  SYNOPSIS
  552.  *      LONG SeekARPFile(file, position, mode)
  553.  *                       ARPFileHandle *file;
  554.  *                       LONG           position;
  555.  *                       LONG           mode;
  556.  *
  557.  *  DESCRIPTION
  558.  *      SeekARPFile attempts to position the <file> to a new logical
  559.  *      position or report it's current position. The <position>
  560.  *      parameter represets a signed offset. The <mode> parameter may
  561.  *      be one of:
  562.  *
  563.  *          OFFSET_BEGINNING (-1) => from beginning of file
  564.  *          OFFSET_CURRENT (0)    => from current position
  565.  *          OFFSET_END (-1)       => from end of file
  566.  *
  567.  *      On output files, the current buffer contents, if any, are
  568.  *      written to disk.
  569.  *
  570.  *      The return value will either be a positive displacement >=0) or
  571.  *      a negated system error code.
  572.  */
  573.  
  574. LONG
  575. SeekARPFile(ARPFileHandle *file,LONG position,LONG mode)
  576. {
  577.     LONG newPosition;
  578.  
  579.     if(file -> mode == MODE_NEWFILE && file -> bufLength)
  580.     {
  581.         if(FlushARPFileBuffer(file) < 0)
  582.         {
  583. farboo:            return(-file -> lastError);
  584.         }
  585.     }
  586.  
  587.         /* Remember our last position. Seek(file,...) fixed
  588.          * to use Seek(file -> fh,...) -Olsen.
  589.          */
  590.  
  591.     file -> lastPosition = Seek(file -> fh, 0L, OFFSET_CURRENT);
  592.  
  593.     if((newPosition = Seek(file -> fh, position, mode)) == -1)
  594.     {
  595.         file -> lastError = IoErr();
  596.         goto farboo;
  597.     }
  598.  
  599.     return(newPosition);
  600. }  
  601.  
  602. /*  FUNCTION
  603.  *      WriteARPFile - write data to a buffered ARP file.
  604.  *
  605.  *  SYNOPSIS
  606.  *      LONG WriteARPFile(file, buffer, length)
  607.  *                        ARPFileHandle *file;
  608.  *                        UBYTE         *buffer;
  609.  *                        LONG          length;
  610.  *
  611.  *  DESCRIPTION
  612.  *      WriteARPFile attempts to write <length> bytes from <buffer> to
  613.  *      the buffered ARP file, <file>. The file MUST have been opened
  614.  *      with OpenARPFile for MODE_NEWFILE access.
  615.  *
  616.  *      WriteARPFile will not write to a file if the lastError field is
  617.  *      non-zero, or if the file was opened for input.
  618.  *
  619.  *      If successful, WriteARPFile will return the <length> parameter.
  620.  *      Otherwise, it will return a negated system error code.
  621.  */
  622.  
  623. LONG
  624. WriteARPFile(ARPFileHandle *file,UBYTE *buffer,LONG length)
  625. {
  626.     LONG    bufferBytes;
  627.     LONG    bytesLeft = length;
  628.     LONG    pos = 0;
  629.     LONG    usedBytes = 0;
  630.  
  631.     if(file -> mode != MODE_NEWFILE)
  632.         file -> lastError = ERROR_WRITE_PROTECTED;
  633.  
  634.         /* Catches mode and residual errors. */
  635.  
  636.     if(file -> lastError)
  637.     {
  638. sumbidge:    return(-file -> lastError);
  639.     }
  640.  
  641.         /* No buffer? */
  642.  
  643.     if(!file -> buf)
  644.     {
  645.         if(Write(file -> fh, buffer, length) != length)
  646.         {
  647.             file -> lastError = IoErr();
  648.             goto sumbidge;
  649.         }
  650.     }
  651.     else
  652.     {
  653.         while(bytesLeft)
  654.         {
  655.                 /* Need to flush the file's buffer? */
  656.  
  657.             if(file -> bufPos >= file -> bufSize)
  658.                 if(FlushARPFileBuffer(file) < 0)
  659.                     goto sumbidge;
  660.  
  661.             bufferBytes = file -> bufSize - file -> bufPos;
  662.  
  663.             usedBytes = MIN(bufferBytes, bytesLeft);
  664.  
  665.             CopyMem(&buffer[pos], &file -> buf[file -> bufPos], usedBytes);
  666.  
  667.             file -> bufLength = (file -> bufPos += usedBytes);
  668.  
  669.             pos += usedBytes;
  670.  
  671.             bytesLeft -= usedBytes;
  672.         }
  673.     }
  674.  
  675.     return(length);
  676. }
  677.